metrics | chef

             # Waitlast - this is magic.

             #

             # Do we wait for the child process to die before we yield

             # to the block, or after?  That is the magic of waitlast.

             #

             # By default, we are waiting before we yield the block.

             args[:waitlast] ||= false

             args[:user] ||= nil

             unless args[:user].kind_of?(Integer)

               args[:user] = Etc.getpwnam(args[:user]).uid if args[:user]

             end

             args[:group] ||= nil

             unless args[:group].kind_of?(Integer)

               args[:group] = Etc.getgrnam(args[:group]).gid if args[:group]

             end

             args[:environment] ||= {}

             # Default on C locale so parsing commands output can be done

             # independently of the node's default locale.

             # "LC_ALL" could be set to nil, in which case we also must ignore it.

             unless args[:environment].has_key?("LC_ALL")

               args[:environment]["LC_ALL"] = "C"

             end

             pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe

             verbose = $VERBOSE

             begin

               $VERBOSE = nil

               ps.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)

               cid = fork {

                 pw.last.close

                 STDIN.reopen pw.first

                 pw.first.close

                 pr.first.close

                 STDOUT.reopen pr.last

                 pr.last.close

                 pe.first.close

                 STDERR.reopen pe.last

                 pe.last.close

                 STDOUT.sync = STDERR.sync = true

                 if args[:group]

                   Process.egid = args[:group]

                   Process.gid = args[:group]

                 end

                 if args[:user]

                   Process.euid = args[:user]

                   Process.uid = args[:user]

                 end

                 args[:environment].each do |key,value|

                   ENV[key] = value

                 end

                 if args[:umask]

                   umask = ((args[:umask].respond_to?(:oct) ? args[:umask].oct : args[:umask].to_i) & 007777)

                   File.umask(umask)

                 end

                 begin

                   if cmd.kind_of?(Array)

                     exec(*cmd)

                   else

                     exec(cmd)

                   end

                   raise 'forty-two'

                 rescue Exception => e

                   Marshal.dump(e, ps.last)

                   ps.last.flush

                 end

                 ps.last.close unless (ps.last.closed?)

                 exit!

               }

             ensure

               $VERBOSE = verbose

             end

             [pw.first, pr.last, pe.last, ps.last].each{|fd| fd.close}

             begin

               e = Marshal.load ps.first

               raise(Exception === e ? e : "unknown failure!")

             rescue EOFError # If we get an EOF error, then the exec was successful

               42

             ensure

               ps.first.close

             end

             pw.last.sync = true

             pi = [pw.last, pr.first, pe.first]

             if b

               begin

                 if args[:waitlast]

                   b[cid, *pi]

                   # send EOF so that if the child process is reading from STDIN

                   # it will actually finish up and exit

                   pi[0].close_write

                   Process.waitpid2(cid).last

                 else

                   # This took some doing.

                   # The trick here is to close STDIN

                   # Then set our end of the childs pipes to be O_NONBLOCK

                   # Then wait for the child to die, which means any IO it

                   # wants to do must be done - it's dead.  If it isn't,

                   # it's because something totally skanky is happening,

                   # and we don't care.

                   o = StringIO.new

                   e = StringIO.new

                   pi[0].close

                   stdout = pi[1]

                   stderr = pi[2]

                   stdout.sync = true

                   stderr.sync = true

                   stdout.fcntl(Fcntl::F_SETFL, pi[1].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)

                   stderr.fcntl(Fcntl::F_SETFL, pi[2].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)

                   stdout_finished = false

                   stderr_finished = false

                   results = nil

                   while !stdout_finished || !stderr_finished

                     begin

                       channels_to_watch = []

                       channels_to_watch << stdout if !stdout_finished

                       channels_to_watch << stderr if !stderr_finished

                       ready = IO.select(channels_to_watch, nil, nil, 1.0)

                     rescue Errno::EAGAIN

                     ensure

                       results = Process.waitpid2(cid, Process::WNOHANG)

                       if results

                         stdout_finished = true

                         stderr_finished = true

                       end

                     end

                     if ready && ready.first.include?(stdout)

                       line = results ? stdout.gets(nil) : stdout.gets

                       if line

                         o.write(line)

                       else

                         stdout_finished = true

                       end

                     end

                     if ready && ready.first.include?(stderr)

                       line = results ? stderr.gets(nil) : stderr.gets

                       if line

                         e.write(line)

                       else

                         stderr_finished = true

                       end

                     end

                   end

                   results = Process.waitpid2(cid) unless results

                   o.rewind

                   e.rewind

                   b[cid, pi[0], o, e]

                   results.last

                 end

               ensure

                 pi.each{|fd| fd.close unless fd.closed?}

               end

             else

               [cid, pw.last, pr.first, pe.first]

             end

           end

         end

       end

     end

   end

           @platforms ||= {

             :mac_os_x => {

               :default => {

                 :package => Chef::Provider::Package::Macports,

                 :user => Chef::Provider::User::Dscl,

                 :group => Chef::Provider::Group::Dscl

               }

             },

             :mac_os_x_server => {

               :default => {

                 :package => Chef::Provider::Package::Macports,

                 :user => Chef::Provider::User::Dscl,

                 :group => Chef::Provider::Group::Dscl

               }

             },

             :freebsd => {

               :default => {

                 :group   => Chef::Provider::Group::Pw,

                 :package => Chef::Provider::Package::Freebsd,

                 :service => Chef::Provider::Service::Freebsd,

                 :user    => Chef::Provider::User::Pw,

                 :cron    => Chef::Provider::Cron

               }

             },

             :ubuntu   => {

               :default => {

                 :package => Chef::Provider::Package::Apt,

                 :service => Chef::Provider::Service::Debian,

                 :cron => Chef::Provider::Cron,

                 :mdadm => Chef::Provider::Mdadm

               }

             },

             :debian => {

               :default => {

                 :package => Chef::Provider::Package::Apt,

                 :service => Chef::Provider::Service::Debian,

                 :cron => Chef::Provider::Cron,

                 :mdadm => Chef::Provider::Mdadm

               },

               "6.0" => {

                 :service => Chef::Provider::Service::Insserv

               }

             },

             :xenserver   => {

               :default => {

                 :service => Chef::Provider::Service::Redhat,

                 :cron => Chef::Provider::Cron,

                 :package => Chef::Provider::Package::Yum,

                 :mdadm => Chef::Provider::Mdadm

               }

             },

             :centos   => {

               :default => {

                 :service => Chef::Provider::Service::Redhat,

                 :cron => Chef::Provider::Cron,

                 :package => Chef::Provider::Package::Yum,

                 :mdadm => Chef::Provider::Mdadm

               }

             },

             :amazon   => {

               :default => {

                 :service => Chef::Provider::Service::Redhat,

                 :cron => Chef::Provider::Cron,

                 :package => Chef::Provider::Package::Yum,

                 :mdadm => Chef::Provider::Mdadm

               }

             },

             :scientific => {

               :default => {

                 :service => Chef::Provider::Service::Redhat,

                 :cron => Chef::Provider::Cron,

                 :package => Chef::Provider::Package::Yum,

                 :mdadm => Chef::Provider::Mdadm

               }

             },

             :fedora   => {

               :default => {

                 :service => Chef::Provider::Service::Redhat,

                 :cron => Chef::Provider::Cron,

                 :package => Chef::Provider::Package::Yum,

                 :mdadm => Chef::Provider::Mdadm

               }

             },

             :suse     => {

               :default => {

                 :service => Chef::Provider::Service::Redhat,

                 :cron => Chef::Provider::Cron,

                 :package => Chef::Provider::Package::Zypper,

                 :group => Chef::Provider::Group::Suse

               }

             },

             :redhat   => {

               :default => {

                 :service => Chef::Provider::Service::Redhat,

                 :cron => Chef::Provider::Cron,

                 :package => Chef::Provider::Package::Yum,

                 :mdadm => Chef::Provider::Mdadm

               }

             },

             :gentoo   => {

               :default => {

                 :package => Chef::Provider::Package::Portage,

                 :service => Chef::Provider::Service::Gentoo,

                 :cron => Chef::Provider::Cron,

                 :mdadm => Chef::Provider::Mdadm

               }

             },

             :arch   => {

               :default => {

                 :package => Chef::Provider::Package::Pacman,

                 :service => Chef::Provider::Service::Arch,

                 :cron => Chef::Provider::Cron,

                 :mdadm => Chef::Provider::Mdadm

               }

             },

             :mswin => {

               :default => {

                 :env =>  Chef::Provider::Env::Windows,

                 :service => Chef::Provider::Service::Windows,

                 :user => Chef::Provider::User::Windows,

                 :group => Chef::Provider::Group::Windows,

                 :mount => Chef::Provider::Mount::Windows

               }

             },

             :mingw32 => {

               :default => {

                 :env =>  Chef::Provider::Env::Windows,

                 :service => Chef::Provider::Service::Windows,

                 :user => Chef::Provider::User::Windows,

                 :group => Chef::Provider::Group::Windows,

                 :mount => Chef::Provider::Mount::Windows

               }

             },

             :windows => {

               :default => {

                 :env =>  Chef::Provider::Env::Windows,

                 :service => Chef::Provider::Service::Windows,

                 :user => Chef::Provider::User::Windows,

                 :group => Chef::Provider::Group::Windows,

                 :mount => Chef::Provider::Mount::Windows

               }

             },

             :solaris  => {},

             :openindiana => {

               :default => {

                 :service => Chef::Provider::Service::Solaris,

                 :package => Chef::Provider::Package::Solaris,

                 :cron => Chef::Provider::Cron::Solaris,

                 :group => Chef::Provider::Group::Usermod

               }

             },

             :opensolaris => {

               :default => {

                 :service => Chef::Provider::Service::Solaris,

                 :package => Chef::Provider::Package::Solaris,

                 :cron => Chef::Provider::Cron::Solaris,

                 :group => Chef::Provider::Group::Usermod

               }

             },

             :nexentacore => {

               :default => {

                 :service => Chef::Provider::Service::Solaris,

                 :package => Chef::Provider::Package::Solaris,

                 :cron => Chef::Provider::Cron::Solaris,

                 :group => Chef::Provider::Group::Usermod

               }

             },

             :solaris2 => {

               :default => {

                 :service => Chef::Provider::Service::Solaris,

                 :package => Chef::Provider::Package::Solaris,

                 :cron => Chef::Provider::Cron::Solaris,

                 :group => Chef::Provider::Group::Usermod

               }

             },

             :netbsd => {

               :default => {

                 :group => Chef::Provider::Group::Usermod

               }

             },

             :openbsd => {

               :default => {

                 :group => Chef::Provider::Group::Usermod

               }

             },

             :hpux => {

               :default => {

                 :group => Chef::Provider::Group::Usermod

               }

             },

             :aix => {

               :default => {

                 :group => Chef::Provider::Group::Aix

               }

             },

             :default  => {

               :file => Chef::Provider::File,

               :directory => Chef::Provider::Directory,

               :link => Chef::Provider::Link,

               :template => Chef::Provider::Template,

               :remote_directory => Chef::Provider::RemoteDirectory,

               :execute => Chef::Provider::Execute,

               :mount => Chef::Provider::Mount::Mount,

               :script => Chef::Provider::Script,

               :service => Chef::Provider::Service::Init,

               :perl => Chef::Provider::Script,

               :python => Chef::Provider::Script,

               :ruby => Chef::Provider::Script,

               :bash => Chef::Provider::Script,

               :csh => Chef::Provider::Script,

               :user => Chef::Provider::User::Useradd,

               :group => Chef::Provider::Group::Gpasswd,

               :http_request => Chef::Provider::HttpRequest,

               :route => Chef::Provider::Route,

               :ifconfig => Chef::Provider::Ifconfig,

               :ruby_block => Chef::Provider::RubyBlock,

               :erl_call => Chef::Provider::ErlCall,

               :log => Chef::Provider::Log::ChefLog

             }

           }

         end

           provider_map = platforms[:default].clone

           name_sym = name

           if name.kind_of?(String)

             name.downcase!

             name.gsub!(/\s/, "_")

             name_sym = name.to_sym

           end

           if platforms.has_key?(name_sym)

             if platforms[name_sym].has_key?(version)

               Chef::Log.debug("Platform #{name.to_s} version #{version} found")

               if platforms[name_sym].has_key?(:default)

                 provider_map.merge!(platforms[name_sym][:default])

               end

               provider_map.merge!(platforms[name_sym][version])

             elsif platforms[name_sym].has_key?(:default)

               provider_map.merge!(platforms[name_sym][:default])

             end

           else

             Chef::Log.debug("Platform #{name} not found, using all defaults. (Unsupported platform?)")

           end

           provider_map

         end

           platform = nil

           version = nil

           if node[:platform]

             platform = node[:platform]

           elsif node.attribute?("os")

             platform = node[:os]

           end

           raise ArgumentError, "Cannot find a platform for #{node}" unless platform

           if node[:platform_version]

             version = node[:platform_version]

           elsif node[:os_version]

             version = node[:os_version]

           elsif node[:os_release]

             version = node[:os_release]

           end

           raise ArgumentError, "Cannot find a version for #{node}" unless version

           return platform, version

         end

           node = resource.run_context && resource.run_context.node

           raise ArgumentError, "Cannot find the provider for a resource with no run context set" unless node

           find_provider_for_node(node, resource).new(resource, resource.run_context)

         end

           raise NotImplementedError, "#{self.class.name} no longer supports #provider_for_node"

           find_provider_for_node(node, resource_type).new(node, resource_type)

         end

           platform, version = find_platform_and_version(node)

           provider = find_provider(platform, version, resource_type)

         end

           validate(

             args,

             {

               :platform => {

                 :kind_of => Symbol,

                 :required => false,

               },

               :version => {

                 :kind_of => String,

                 :required => false,

               },

               :resource => {

                 :kind_of => Symbol,

               },

               :provider => {

                 :kind_of => [ String, Symbol, Class ],

               }

             }

           )

           if args.has_key?(:platform)

             if args.has_key?(:version)

               if platforms.has_key?(args[:platform])

                 if platforms[args[:platform]].has_key?(args[:version])

                   platforms[args[:platform]][args[:version]][args[:resource].to_sym] = args[:provider]

                 else

                   platforms[args[:platform]][args[:version]] = {

                     args[:resource].to_sym => args[:provider]

                   }

                 end

               else

                 platforms[args[:platform]] = {

                   args[:version] => {

                     args[:resource].to_sym => args[:provider]

                   }

                 }

               end

             else

               if platforms.has_key?(args[:platform])

                 if platforms[args[:platform]].has_key?(:default)

                   platforms[args[:platform]][:default][args[:resource].to_sym] = args[:provider]

                 else

                   platforms[args[:platform]] = { :default => { args[:resource].to_sym => args[:provider] } }

                 end

               else

                 platforms[args[:platform]] = {

                   :default => {

                     args[:resource].to_sym => args[:provider]

                   }

                 }

               end

             end

           else

             if platforms.has_key?(:default)

               platforms[:default][args[:resource].to_sym] = args[:provider]

             else

               platforms[:default] = {

                 args[:resource].to_sym => args[:provider]

               }

             end

           end

         end

           pmap = Chef::Platform.find(platform, version)

           provider_klass = explicit_provider(platform, version, resource_type) ||

                            platform_provider(platform, version, resource_type) ||

                            resource_matching_provider(platform, version, resource_type)

           raise ArgumentError, "Cannot find a provider for #{resource_type} on #{platform} version #{version}" if provider_klass.nil?

           provider_klass

         end

             resource_type.kind_of?(Chef::Resource) ? resource_type.provider : nil

           end

             pmap = Chef::Platform.find(platform, version)

             rtkey = resource_type.kind_of?(Chef::Resource) ? resource_type.resource_name.to_sym : resource_type

             pmap.has_key?(rtkey) ? pmap[rtkey] : nil

           end

             if resource_type.kind_of?(Chef::Resource)

               begin

                 Chef::Provider.const_get(resource_type.class.to_s.split('::').last)

               rescue NameError

                 nil

               end

             else

               nil

             end

           end

       end

     end

   end

             @current_resource = Chef::Resource::Package.new(@new_resource.name)

             @current_resource.package_name(@new_resource.package_name)

             @current_resource.version(current_installed_version)

             Chef::Log.debug("#{@new_resource} current version is #{@current_resource.version}") if @current_resource.version

             @candidate_version = macports_candidate_version

             if !@new_resource.version and !@candidate_version

               raise Chef::Exceptions::Package, "Could not get a candidate version for this package -- #{@new_resource.name} does not seem to be a valid package!"

             end

             Chef::Log.debug("#{@new_resource} candidate version is #{@candidate_version}") if @candidate_version

             @current_resource

           end

             command = "port installed #{@new_resource.package_name}"

             output = get_response_from_command(command)

             response = nil

             output.each_line do |line|

               match = line.match(/^.+ @([^\s]+) \(active\)$/)

               response = match[1] if match

             end

             response

           end

             command = "port info --version #{@new_resource.package_name}"

             output = get_response_from_command(command)

             match = output.match(/^version: (.+)$/)

             match ? match[1] : nil

           end

             unless @current_resource.version == version

               command = "port#{expand_options(@new_resource.options)} install #{name}"

               command << " @#{version}" if version and !version.empty? 

               run_command_with_systems_locale(

                 :command => command

               )

             end

           end

             command = "port#{expand_options(@new_resource.options)} uninstall #{name}"

             command << " @#{version}" if version and !version.empty?

             run_command_with_systems_locale(

               :command => command

             )

           end

             command = "port#{expand_options(@new_resource.options)} deactivate #{name}"

             command << " @#{version}" if version and !version.empty?

             run_command_with_systems_locale(

               :command => command

             )

           end

             # Saving this to a variable -- weird rSpec behavior

             # happens otherwise...

             current_version = @current_resource.version

             if current_version.nil? or current_version.empty?

               # Macports doesn't like when you upgrade a package

               # that hasn't been installed.

               install_package(name, version)

             elsif current_version != version

               run_command_with_systems_locale(

                 :command => "port#{expand_options(@new_resource.options)} upgrade #{name} @#{version}"

               )

             end

           end

             output = nil

             status = popen4(command) do |pid, stdin, stdout, stderr|

               begin

                 output = stdout.read

               rescue Exception

                 raise Chef::Exceptions::Package, "Could not read from STDOUT on command: #{command}"

               end

             end

             unless status.exitstatus == 0 || status.exitstatus == 1

               raise Chef::Exceptions::Package, "#{command} failed - #{status.insect}!"

             end

             output

           end

         end

       end

     end

   end

           # irb breaks if you prematurely define IRB::JobMangager

           # so these methods need to be defined at the latest possible time.

           unless jobs.respond_to?(:select_session_by_context)

             def jobs.select_session_by_context(&block)

               @jobs.select { |job| block.call(job[1].context.main)}

             end

           end

           unless jobs.respond_to?(:session_select)

             def jobs.select_shef_session(target_context)

               session = if target_context.kind_of?(Class)

                 select_session_by_context { |main| main.kind_of?(target_context) }

               else

                 select_session_by_context { |main| main.equal?(target_context) }

               end

               Array(session.first)[1]

             end

           end

         end

           ensure_session_select_defined

           if subsession = jobs.select_shef_session(context_obj)

             jobs.switch(subsession)

           else

             irb(context_obj)

           end

         end

           banner = []

           banner << ""

           banner << "Shef Help"

           banner << "".ljust(80, "=")

           banner << "| " + "Command".ljust(25) + "| " + "Description"

           banner << "".ljust(80, "=")

           self.all_help_descriptions.each do |help_text|

             banner << "| " + help_text.cmd.ljust(25) + "| " + help_text.desc

           end

           banner << "".ljust(80, "=")

           banner << "\n"

           banner << "Use help(:command) to get detailed help with individual commands"

           banner << "\n"

           banner.join("\n")

         end

           help = self.all_help_descriptions.find { |h| h.cmd.to_s == method_name.to_s }

           if help

             puts ""

             puts "Command: #{method_name}"

             puts "".ljust(80, "=")

             puts help.explanation || help.desc

             puts "".ljust(80, "=")

             puts ""

           else

             puts ""

             puts "command #{method_name} not found or no help available"

             puts ""

           end

         end

           :on

         end

           :off

         end

           @help_descriptions ||= []

         end

           help_descriptions

         end

           @desc = help_text

         end

           @explain = explain_text

         end

           @subcommand_help = subcommand_help

         end

           if @desc

             help_descriptions << Help.new(mname.to_s, @desc.to_s, @explain)

             @desc, @explain = nil, nil

           end

           if @subcommand_help

             @subcommand_help.each do |subcommand, text|

               help_descriptions << Help.new("#{mname}.#{subcommand}", text.to_s, nil)

             end

           end

           @subcommand_help = {}

         end

       end

           case self

           when "on"

             true

           when "off"

             false

           else

             self

           end

         end

       end

           self.to_s.on_off_to_bool

         end

       end

           "on"

         end

           self

         end

       end

           "off"

         end

           self

         end

       end

         extend Shef::Extensions::ObjectCoreExtensions

         desc "prints this help message"

         explain(<<-E)

   ## SUMMARY ##

     When called with no argument, +help+ prints a table of all shef commands. When

     called with an argument COMMAND, +help+ prints a detailed explanation of the

     command if available, or the description if no explanation is available.

   E

         def help(commmand=nil)

           if commmand

             explain_command(commmand)

           else

             puts help_banner

           end

           :ucanhaz_halp

         end

         alias :halp :help

         desc "prints information about chef"

         def version

           puts  "This is shef, the Chef shell.\n" +

                 " Chef Version: #{::Chef::VERSION}\n" +

                 " http://www.opscode.com/chef\n" +

                 " http://wiki.opscode.com/display/chef/Home"

           :ucanhaz_automation

         end

         alias :shef :version

         desc "switch to recipe mode"

         def recipe

           find_or_create_session_for Shef.session.recipe

           :recipe

         end

         desc "switch to attributes mode"

         def attributes

           find_or_create_session_for Shef.session.node

           :attributes

         end

         desc "run chef using the current recipe"

         def run_chef

           Chef::Log.level = :debug

           session = Shef.session

           runrun = Chef::Runner.new(session.run_context).converge

           Chef::Log.level = :info

           runrun

         end

         desc "returns an object to control a paused chef run"

         subcommands :resume       => "resume the chef run",

                     :step         => "run only the next resource",

                     :skip_back    => "move back in the run list",

                     :skip_forward => "move forward in the run list"

         def chef_run

           Shef.session.resource_collection.iterator

         end

         desc "resets the current recipe"

         def reset

           Shef.session.reset!

         end

         desc "assume the identity of another node."

         def become_node(node_name)

           Shef::DoppelGangerSession.instance.assume_identity(node_name)

           :doppelganger

         end

         alias :doppelganger :become_node

         desc "turns printout of return values on or off"

         def echo(on_or_off)

           conf.echo = on_or_off.on_off_to_bool

         end

         desc "says if echo is on or off"

         def echo?

           puts "echo is #{conf.echo.to_on_off_str}"

         end

         desc "turns on or off tracing of execution. *verbose*"

         def tracing(on_or_off)

           conf.use_tracer = on_or_off.on_off_to_bool

           tracing?

         end

         alias :trace :tracing

         desc "says if tracing is on or off"

         def tracing?

           puts "tracing is #{conf.use_tracer.to_on_off_str}"

         end

         alias :trace? :tracing?

         desc "simple ls style command"

         def ls(directory)

           Dir.entries(directory)

         end

       end

         desc "returns the current node (i.e., this host)"

         def node

           Shef.session.node

         end

         desc "pretty print the node's attributes"

         def ohai(key=nil)

           pp(key ? node.attribute[key] : node.attribute)

         end

       end

         desc "edit an object in your EDITOR"

         explain(<<-E)

   ## SUMMARY ##

     +edit(object)+ allows you to edit any object that can be converted to JSON.

     When finished editing, this method will return the edited object:

         new_node = edit(existing_node)

   ## EDITOR SELECTION ##

     Shef looks for an editor using the following logic

     1. Looks for an EDITOR set by Shef.editor = "EDITOR"

     2. Looks for an EDITOR configured in your shef config file

     3. Uses the value of the EDITOR environment variable

   E

         def edit(object)

           unless Shef.editor

             puts "Please set your editor with Shef.editor = \"vim|emacs|mate|ed\""

             return :failburger

           end

           filename = "shef-edit-#{object.class.name}-"

           if object.respond_to?(:name)

             filename += object.name

           elsif object.respond_to?(:id)

             filename += object.id

           end

           edited_data = Tempfile.open([filename, ".js"]) do |tempfile|

             tempfile.sync = true

             tempfile.puts Chef::JSONCompat.to_json(object)

             system("#{Shef.editor.to_s} #{tempfile.path}")

             tempfile.rewind

             tempfile.read

           end

           Chef::JSONCompat.from_json(edited_data)

         end

         desc "Find and edit API clients"

         explain(<<-E)

   ## SUMMARY ##

     +clients+ allows you to query you chef server for information about your api

     clients.

   ## LIST ALL CLIENTS ##

     To see all clients on the system, use

         clients.all #=> [, ...]

     If the output from all is too verbose, or you're only interested in a specific

     value from each of the objects, you can give a code block to +all+:

         clients.all { |client| client.name } #=> [CLIENT1_NAME, CLIENT2_NAME, ...]

   ## SHOW ONE CLIENT ##

     To see a specific client, use

         clients.show(CLIENT_NAME)

   ## SEARCH FOR CLIENTS ##

     You can also search for clients using +find+ or +search+. You can use the

     familiar string search syntax:

         clients.search("KEY:VALUE")

     Just as the +all+ subcommand, the +search+ subcommand can use a code block to

     filter or transform the information returned from the search:

         clients.search("KEY:VALUE") { |c| c.name }

     You can also use a Hash based syntax, multiple search conditions will be 

     joined with AND.

         clients.find :KEY => :VALUE, :KEY2 => :VALUE2, ...

   ## BULK-EDIT CLIENTS ##

                       **BE CAREFUL, THIS IS DESTRUCTIVE**

     You can bulk edit API Clients using the +transform+ subcommand, which requires

     a code block. Each client will be saved after the code block is run. If the

     code block returns +nil+ or +false+, that client will be skipped:

         clients.transform("*:*") do |client|

           if client.name =~ /borat/i

             client.admin(false)

             true

           else

             nil

           end

         end

     This will strip the admin privileges from any client named after borat.

   E

         subcommands :all        => "list all api clients",

                     :show       => "load an api client by name",

                     :search     => "search for API clients",

                     :transform  => "edit all api clients via a code block and save them"

         def clients

           @clients ||= Shef::ModelWrapper.new(Chef::ApiClient, :client)

         end

         desc "Find and edit cookbooks"

         subcommands :all        => "list all cookbooks",

                     :show       => "load a cookbook by name",

                     :transform  => "edit all cookbooks via a code block and save them"

         def cookbooks

           @cookbooks ||= Shef::ModelWrapper.new(Chef::CookbookVersion)

         end

         desc "Find and edit nodes via the API"

         explain(<<-E)

   ## SUMMARY ##

     +nodes+ Allows you to query your chef server for information about your nodes.

   ## LIST ALL NODES ##

     You can list all nodes using +all+ or +list+

         nodes.all #=> [, , ...]

     To limit the information returned for each node, pass a code block to the +all+

     subcommand:

         nodes.all { |node| node.name } #=> [NODE1_NAME, NODE2_NAME, ...]

   ## SHOW ONE NODE ##

     You can show the data for a single node using the +show+ subcommand:

         nodes.show("NODE_NAME") => 

   ## SEARCH FOR NODES ##

     You can search for nodes using the +search+ or +find+ subcommands:

         nodes.find(:name => "app*") #=> [, ...]

     Similarly to +all+, you can pass a code block to limit or transform the

     information returned:

         nodes.find(:name => "app#") { |node| node.ec2 } 

   ## BULK EDIT NODES ##

                 **BE CAREFUL, THIS OPERATION IS DESTRUCTIVE**

     Bulk edit nodes by passing a code block to the +transform+ or +bulk_edit+

     subcommand. The block will be applied to each matching node, and then the node

     will be saved. If the block returns +nil+ or +false+, that node will be 

     skipped.

         nodes.transform do |node|

           if node.fqdn =~ /.*\\.preprod\\.example\\.com/

             node.set[:environment] = "preprod"

           end

         end

     This will assign the attribute to every node with a FQDN matching the regex.

   E

         subcommands :all        => "list all nodes",

                     :show       => "load a node by name",

                     :search     => "search for nodes",

                     :transform  => "edit all nodes via a code block and save them"

         def nodes

           @nodes ||= Shef::ModelWrapper.new(Chef::Node)

         end

         desc "Find and edit roles via the API"

         explain(<<-E)

   ## SUMMARY ##

     +roles+ allows you to query and edit roles on your Chef server.

   ## SUBCOMMANDS ##

     * all       (list)

     * show      (load)

     * search    (find)

     * transform (bulk_edit)

   ## SEE ALSO ##

     See the help for +nodes+ for more information about the subcommands.

   E

         subcommands :all        => "list all roles",

                     :show       => "load a role by name",

                     :search     => "search for roles",

                     :transform  => "edit all roles via a code block and save them"

         def roles

           @roles ||= Shef::ModelWrapper.new(Chef::Role)

         end

         desc "Find and edit +databag_name+ via the api"

         explain(<<-E)

   ## SUMMARY ##

     +databags(DATABAG_NAME)+ allows you to query and edit data bag items on your

     Chef server. Unlike other commands for working with data on the server, 

     +databags+ requires the databag name as an argument, for example:

       databags(:users).all

   ## SUBCOMMANDS ##

     * all       (list)

     * show      (load)

     * search    (find)

     * transform (bulk_edit)

   ## SEE ALSO ##

     See the help for +nodes+ for more information about the subcommands.

   E

         subcommands :all        => "list all items in the data bag",

                     :show       => "load a data bag item by id",

                     :search     => "search for items in the data bag",

                     :transform  => "edit all items via a code block and save them"

         def databags(databag_name)

           @named_databags_wrappers ||= {}

           @named_databags_wrappers[databag_name] ||= Shef::NamedDataBagWrapper.new(databag_name)

         end

         desc "A REST Client configured to authenticate with the API"

         def api

           @rest = Shef::ShefREST.new(Chef::Config[:chef_server_url])

         end

       end

         alias :original_resources :resources

         desc "list all the resources on the current recipe"

         def resources(*args)

           if args.empty?

             pp run_context.resource_collection.instance_variable_get(:@resources_by_name).keys

           else

             pp resources = original_resources(*args)

             resources

           end

         end

       end

         obj.instance_eval(&ObjectUIExtensions)

         obj.instance_eval(&MainContextExtensions)

         obj.instance_eval(&RESTApiExtensions)

         obj.extend(FileUtils)

         obj.extend(Chef::Mixin::Language)

       end

         node_obj.instance_eval(&ObjectUIExtensions)

       end

         recipe_obj.instance_eval(&ObjectUIExtensions)

         recipe_obj.instance_eval(&RecipeUIExtensions)

       end

     end

   end

           super(new_resource, run_context)

           @cron_exists = false

           @cron_empty = false

         end

           crontab_lines = []

           @current_resource = Chef::Resource::Cron.new(@new_resource.name)

           @current_resource.user(@new_resource.user)

           status = popen4("crontab -l -u #{@new_resource.user}") do |pid, stdin, stdout, stderr|

             stdout.each_line { |line| crontab_lines << line }

           end

           if status.exitstatus > 1

             raise Chef::Exceptions::Cron, "Error determining state of #{@new_resource.name}, exit: #{status.exitstatus}"

           elsif status.exitstatus == 0

             cron_found = false

             crontab_lines.each do |line|

               case line.chomp

               when "# Chef Name: #{@new_resource.name}"

                 Chef::Log.debug("Found cron '#{@new_resource.name}'")

                 cron_found = true

                 @cron_exists = true

                 next

               when /^MAILTO=(\S*)/

                 @current_resource.mailto($1) if cron_found

                 next

               when /^PATH=(\S*)/

                 @current_resource.path($1) if cron_found

                 next

               when /^SHELL=(\S*)/

                 @current_resource.shell($1) if cron_found

                 next

               when /^HOME=(\S*)/

                 @current_resource.home($1) if cron_found

                 next

               when CRON_PATTERN

                 if cron_found

                   @current_resource.minute($1)

                   @current_resource.hour($2)

                   @current_resource.day($3)

                   @current_resource.month($4)

                   @current_resource.weekday($5)

                   @current_resource.command($6)

                   cron_found=false

                 end

                 next

               else

                 next

               end

             end

             Chef::Log.debug("Cron '#{@new_resource.name}' not found") unless @cron_exists

           elsif status.exitstatus == 1

             Chef::Log.debug("Cron empty for '#{@new_resource.user}'")

             @cron_empty = true

           end

           @current_resource

         end

           [ :minute, :hour, :day, :month, :weekday, :command, :mailto, :path, :shell, :home ].any? do |cron_var|

             !@new_resource.send(cron_var).nil? && @new_resource.send(cron_var) != @current_resource.send(cron_var)

           end

         end

           crontab = String.new

           newcron = String.new

           cron_found = false

           newcron << "# Chef Name: #{new_resource.name}\n"

           [ :mailto, :path, :shell, :home ].each do |v|

             newcron << "#{v.to_s.upcase}=#{@new_resource.send(v)}\n" if @new_resource.send(v)

           end

           newcron << "#{@new_resource.minute} #{@new_resource.hour} #{@new_resource.day} #{@new_resource.month} #{@new_resource.weekday} #{@new_resource.command}\n"

           if @cron_exists

             unless compare_cron

               Chef::Log.debug("Skipping existing cron entry '#{@new_resource.name}'")

               return

             end

             status = popen4("crontab -l -u #{@new_resource.user}") do |pid, stdin, stdout, stderr|

               stdout.each_line do |line|

                 case line.chomp

                 when "# Chef Name: #{@new_resource.name}"

                   cron_found = true

                   next

                 when CRON_PATTERN

                   if cron_found

                     cron_found = false

                     crontab << newcron

                     next

                   end

                 else

                   next if cron_found

                 end

                 crontab << line

               end

             end

             status = popen4("crontab -u #{@new_resource.user} -", :waitlast => true) do |pid, stdin, stdout, stderr|

               crontab.each_line { |line| stdin.puts "#{line}" }

             end

             Chef::Log.info("#{@new_resource} updated crontab entry")

             @new_resource.updated_by_last_action(true)

           else

             unless @cron_empty

               status = popen4("crontab -l -u #{@new_resource.user}") do |pid, stdin, stdout, stderr|

                 stdout.each { |line| crontab << line }

               end

             end

             crontab << newcron

             status = popen4("crontab -u #{@new_resource.user} -", :waitlast => true) do |pid, stdin, stdout, stderr|

               crontab.each_line { |line| stdin.puts "#{line}" }

             end

             Chef::Log.info("#{@new_resource} added crontab entry")

             @new_resource.updated_by_last_action(true)

           end

         end

           if @cron_exists

             crontab = String.new

             cron_found = false

             status = popen4("crontab -l -u #{@new_resource.user}") do |pid, stdin, stdout, stderr|

               stdout.each_line do |line|

                 case line.chomp

                 when "# Chef Name: #{@new_resource.name}"

                   cron_found = true

                   next

                 when CRON_PATTERN

                   if cron_found

                     cron_found = false

                     next

                   end

                 else

                   next if cron_found

                 end

                 crontab << line

               end

             end

             status = popen4("crontab -u #{@new_resource.user} -", :waitlast => true) do |pid, stdin, stdout, stderr|

               crontab.each_line { |line| stdin.puts "#{line}" }

             end

             Chef::Log.info("#{@new_resource} deleted crontab entry")

             @new_resource.updated_by_last_action(true)

           end

         end

       end

     end

   end

                 return if evr.nil?

                 epoch = nil

                 # assume this is a version

                 version = evr

                 release = nil

                 lead = 0

                 tail = evr.size

                 if evr =~ %r{^([\d]+):}

                   epoch = $1.to_i

                   lead = $1.length + 1

                 elsif evr[0].ord == ":".ord

                   epoch = 0

                   lead = 1

                 end

                 if evr =~ %r{:?.*-(.*)$}

                   release = $1

                   tail = evr.length - release.length - lead - 1

                   if release.empty?

                     release = nil

                   end

                 end

                 version = evr[lead,tail]

                 if version.empty?

                   version = nil

                 end

                 [ epoch, version, release ]

               end

                 isalpha(x) or isdigit(x)

               end

                 v = x.ord

                 (v >= 65 and v <= 90) or (v >= 97 and v <= 122)

               end

                 v = x.ord

                 v >= 48 and v <= 57

               end

                 # easy! :)

                 return 0 if x == y

                 if x.nil?

                   x = ""

                 end

                 if y.nil?

                   y = ""

                 end

                 # not so easy :(

                 #

                 # takes 2 strings like

                 #

                 # x = "1.20.b18.el5"

                 # y = "1.20.b17.el5"

                 #

                 # breaks into purely alpha and numeric segments and compares them using

                 # some rules

                 #

                 # * 10 > 1

                 # * 1 > a

                 # * z > a

                 # * Z > A

                 # * z > Z

                 # * leading zeros are ignored

                 # * separators (periods, commas) are ignored

                 # * "1.20.b18.el5.extrastuff" > "1.20.b18.el5"

                 x_pos = 0                # overall string element reference position

                 x_pos_max = x.length - 1 # number of elements in string, starting from 0

                 x_seg_pos = 0            # segment string element reference position

                 x_comp = nil             # segment to compare

                 y_pos = 0

                 y_seg_pos = 0

                 y_pos_max = y.length - 1

                 y_comp = nil

                 while (x_pos <= x_pos_max and y_pos <= y_pos_max)

                   # first we skip over anything non alphanumeric

                   while (x_pos <= x_pos_max) and (isalnum(x[x_pos]) == false)

                     x_pos += 1 # +1 over pos_max if end of string

                   end

                   while (y_pos <= y_pos_max) and (isalnum(y[y_pos]) == false)

                     y_pos += 1

                   end

                   # if we hit the end of either we are done matching segments

                   if (x_pos == x_pos_max + 1) or (y_pos == y_pos_max + 1)

                     break

                   end

                   # we are now at the start of a alpha or numeric segment

                   x_seg_pos = x_pos

                   y_seg_pos = y_pos

                   # grab segment so we can compare them

                   if isdigit(x[x_seg_pos].ord)

                     x_seg_is_num = true

                     # already know it's a digit

                     x_seg_pos += 1

                     # gather up our digits

                     while (x_seg_pos <= x_pos_max) and isdigit(x[x_seg_pos])

                       x_seg_pos += 1

                     end

                     # copy the segment but not the unmatched character that x_seg_pos will

                     # refer to

                     x_comp = x[x_pos,x_seg_pos - x_pos]

                     while (y_seg_pos <= y_pos_max) and isdigit(y[y_seg_pos])

                       y_seg_pos += 1

                     end

                     y_comp = y[y_pos,y_seg_pos - y_pos]

                   else

                     # we are comparing strings

                     x_seg_is_num = false

                     while (x_seg_pos <= x_pos_max) and isalpha(x[x_seg_pos])

                       x_seg_pos += 1

                     end

                     x_comp = x[x_pos,x_seg_pos - x_pos]